home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_0799 / 509 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  13.4 KB
  1. From: inf2gr04@informatik.uni-frankfurt.de
  2. Posted-Date: Tue, 21 Sep 93 12:51:33 MESZ
  3. Received-Date: Tue, 21 Sep 93 12:51:34 +0200
  4. Message-Id: <9309211051.AA06364@hptest.rbi.informatik.uni-frankfurt.de>
  5. Subject: more MiNT 1.09 bugs
  6. To: mint@atari.archive.umich.edu
  7. Date: Tue, 21 Sep 93 12:51:33 MESZ
  8. Mailer: Elm [revision: 70.85]
  9.  
  10.  
  11. I encountered two problems with MiNT 1.09. First a short description,
  12. followed by context diff's to patch them. (The patches for both of them
  13. are mixed up in the same file, sorry :-).
  14.  
  15. 1.)    If you change the flow-control state of a serial device
  16.     (u:/dev/modem1, ...) with the TIOCSFLAGS ioctl() (TANDEM, RTSCTS
  17.     Bits), then you dont't get the correct state of them with
  18.     following TIOCGFLAGS ioctl()'s (they rely on the saved state
  19.     in the sg.sg_flags member of the struct tty, which is not
  20.     updated by TIOCSFLAGS calls).
  21.  
  22. 2.)    Fselect() does not work properly when several processes are  selecting
  23.     on the same file (there're no provisions to handle collisions). For
  24.     instance, if two processes are selecting on the same sets of files,
  25.     the second one doing the Fselect() is blocked forever (provided no
  26.     timeout is specified and no signals are delivered), even if the
  27.     specified descriptors become ready for doing IO. The fix requires
  28.     support from the device-drivers select() routine. The return values
  29.     from select() should be:
  30.         0 -- not ready for IO, register for selecting (not changed)
  31.         1 -- ready for IO (not changed)
  32.         2 -- collision (not ready, but no room to hold
  33.              another process for selection on that file)
  34.     All the other work is done in f_select(). Because collisions happen
  35.     rather rarely, it's not worth to make the device-drivers select()
  36.     able to hold an arbitrary number of processes for selection on the same
  37.     file or device.
  38.     The device drivers should just be able to hold one process and return
  39.     '2' at further requests to hold another process at the same time for
  40.     the same file or device (see pipe_select for example).
  41.  
  42. The following cdiffs are relative to MiNT 1.09, it would be nice if they
  43. could be applied to new MiNT versions (to Eric ...).
  44.  
  45. cheers, Kay Roemer.
  46.  
  47. *** biosfs.c.orig    Sun Sep  5 20:18:00 1993
  48. --- biosfs.c    Mon Sep 13 21:41:28 1993
  49. ***************
  50. *** 1144,1150 ****
  51. --- 1144,1154 ----
  52.                   oflags |= (ucr & 0x2) ? T_EVENP : T_ODDP;
  53.               }
  54.               if (mode == TIOCSFLAGS) {
  55. +                 ushort *sg_flags =
  56. +                     &((struct tty *)f->devinfo)->sg.sg_flags;
  57.                   flags = (*(unsigned short *)buf);
  58. +                 *sg_flags &= ~(T_RTSCTS|T_TANDEM);
  59. +                 *sg_flags |= flags & (T_RTSCTS|T_TANDEM);
  60.                   if (flags & T_EVENP) {
  61.                       ucr |= 0x6;
  62.                   } else if (flags & T_ODDP) {
  63. ***************
  64. *** 1236,1243 ****
  65.           }
  66.           if (tty) {
  67.           /* avoid collisions with other processes */
  68. !             if (!tty->rsel)
  69. !                 tty->rsel = p;
  70.           }
  71.           return 0;
  72.       } else if (mode == O_WRONLY) {
  73. --- 1240,1248 ----
  74.           }
  75.           if (tty) {
  76.           /* avoid collisions with other processes */
  77. !             if (tty->rsel)
  78. !                 return 2; /* collsion */
  79. !             tty->rsel = p;
  80.           }
  81.           return 0;
  82.       } else if (mode == O_WRONLY) {
  83. ***************
  84. *** 1246,1253 ****
  85.               return 1;
  86.           }
  87.           if (tty) {
  88. !             if (!tty->wsel)
  89. !                 tty->wsel = p;
  90.           }
  91.           return 0;
  92.       }
  93. --- 1251,1259 ----
  94.               return 1;
  95.           }
  96.           if (tty) {
  97. !             if (tty->wsel)
  98. !                 return 2; /* collision */
  99. !             tty->wsel = p;
  100.           }
  101.           return 0;
  102.       }
  103. ***************
  104. *** 1482,1489 ****
  105.       if (mousetail - mousehead)
  106.           return 1;    /* input waiting already */
  107.   
  108. !     if (!mousersel)
  109. !         mousersel = p;
  110.       return 0;
  111.   }
  112.   
  113. --- 1488,1496 ----
  114.       if (mousetail - mousehead)
  115.           return 1;    /* input waiting already */
  116.   
  117. !     if (mousersel)
  118. !         return 2; /* collision */
  119. !     mousersel = p;
  120.       return 0;
  121.   }
  122.   
  123. *** dosfile.c.orig    Mon Sep 13 18:32:46 1993
  124. --- dosfile.c    Mon Sep 13 23:02:06 1993
  125. ***************
  126. *** 11,16 ****
  127. --- 11,19 ----
  128.   static long do_dup P_((int,int));
  129.   static void unselectme P_((PROC *));
  130.   
  131. + /* wait condition for selecting processes which got collisions */
  132. + short select_coll;
  133. + 
  134.   /*
  135.    * first, some utility routines
  136.    */
  137. ***************
  138. *** 274,279 ****
  139. --- 277,284 ----
  140.       if (f->dev) {
  141.           (*f->dev->unselect)(f, (long)p, O_RDONLY);
  142.           (*f->dev->unselect)(f, (long)p, O_WRONLY);
  143. + /* give other processes a chance to select on this file */
  144. +         wake(SELECT_Q, (long)&select_coll);
  145.       }
  146.   
  147.       f->links--;
  148. ***************
  149. *** 957,983 ****
  150.       unsigned timeout;
  151.       long *rfdp, *wfdp, *xfdp;
  152.   {
  153. !     long rfd, wfd;
  154.       long mask, bytes;
  155.       int i, count;
  156.       FILEPTR *f;
  157.       PROC *p;
  158. !     TIMEOUT *t;
  159.       short sr;
  160.   
  161.       if (xfdp)
  162.           *xfdp = 0;
  163.   
  164.       if (rfdp) {
  165. !         rfd = *rfdp; *rfdp = 0;
  166.       }
  167.       else
  168. !         rfd = 0;
  169.       if (wfdp) {
  170. !         wfd = *wfdp; *wfdp = 0;
  171.       }
  172.       else
  173. !         wfd = 0;
  174.   
  175.       TRACE(("Fselect(%u, %lx, %lx)", timeout, rfd, wfd));
  176.       p = curproc;            /* help the optimizer out */
  177. --- 962,988 ----
  178.       unsigned timeout;
  179.       long *rfdp, *wfdp, *xfdp;
  180.   {
  181. !     long rfd, wfd, orfd, owfd;
  182.       long mask, bytes;
  183.       int i, count;
  184.       FILEPTR *f;
  185.       PROC *p;
  186. !     TIMEOUT *t = 0;
  187.       short sr;
  188.   
  189.       if (xfdp)
  190.           *xfdp = 0;
  191.   
  192.       if (rfdp) {
  193. !         orfd = rfd = *rfdp; *rfdp = 0;
  194.       }
  195.       else
  196. !         orfd = rfd = 0;
  197.       if (wfdp) {
  198. !         owfd = wfd = *wfdp; *wfdp = 0;
  199.       }
  200.       else
  201. !         owfd = wfd = 0;
  202.   
  203.       TRACE(("Fselect(%u, %lx, %lx)", timeout, rfd, wfd));
  204.       p = curproc;            /* help the optimizer out */
  205. ***************
  206. *** 985,991 ****
  207.       /* first, validate the masks */
  208.       mask = 1L;
  209.       for (i = 0; i < MAX_OPEN; i++) {
  210. !         if ( ((rfd & mask) || (wfd & mask)) && !(p->handle[i]) ) {
  211.               DEBUG(("Fselect: invalid handle: %d", i));
  212.               return EIHNDL;
  213.           }
  214. --- 990,996 ----
  215.       /* first, validate the masks */
  216.       mask = 1L;
  217.       for (i = 0; i < MAX_OPEN; i++) {
  218. !         if ( ((orfd & mask) || (owfd & mask)) && !(p->handle[i]) ) {
  219.               DEBUG(("Fselect: invalid handle: %d", i));
  220.               return EIHNDL;
  221.           }
  222. ***************
  223. *** 1001,1035 ****
  224.    * closed one of the handles.
  225.    */
  226.   
  227. -     mask = 1L;
  228.       count = 0;
  229.       curproc->wait_cond = (long)wakeselect;        /* flag */
  230.   
  231.       for (i = 0; i < MAX_OPEN; i++) {
  232.           if (rfd & mask) {
  233.               f = p->handle[i];
  234. !             if ((*f->dev->select)(f, (long)p, O_RDONLY)) {
  235.                   count++;
  236.                   *rfdp |= mask;
  237.               }
  238.           }
  239.           if (wfd & mask) {
  240.               f = p->handle[i];
  241. !             if ((*f->dev->select)(f, (long)p, O_WRONLY)) {
  242.                   count++;
  243.                   *wfdp |= mask;
  244.               }
  245.           }
  246.           mask = mask << 1L;
  247.       }
  248.   
  249.       if (count == 0) {
  250. !         /* OK, now let's set a timeout */
  251.   
  252. !         if (timeout) {
  253.               t = addtimeout((long)timeout, unselectme);
  254. -         } else {
  255. -             t = 0;
  256.           }
  257.   
  258.           sr = spl7();
  259. --- 1006,1058 ----
  260.    * closed one of the handles.
  261.    */
  262.   
  263.       count = 0;
  264.       curproc->wait_cond = (long)wakeselect;        /* flag */
  265.   
  266. + 
  267. + /* NOTE to the above note: since we can get here several times (in
  268. +  * case of collisions) after we've gone to sleep, we probably cannot
  269. +  * assume the filepointers are valid.
  270. +  * I'm not really sure, because `post_sig' sets curproc->wait_cond
  271. +  * to zero and then we cannot get here after we've gone to sleep. 
  272. +  */
  273. +  
  274. + retry_after_collision:
  275. +     mask = 1L;
  276. +     
  277.       for (i = 0; i < MAX_OPEN; i++) {
  278.           if (rfd & mask) {
  279.               f = p->handle[i];
  280. !             if (f) {
  281. !                 switch ((*f->dev->select)(f, (long)p, O_RDONLY)) {
  282. !                 case 1:
  283.                   count++;
  284.                   *rfdp |= mask;
  285. +                 case 0:
  286. +                 rfd &= ~mask;
  287. +                 }
  288.               }
  289.           }
  290.           if (wfd & mask) {
  291.               f = p->handle[i];
  292. !             if (f) {
  293. !                 switch ((*f->dev->select)(f, (long)p, O_WRONLY)) {
  294. !                 case 1:
  295.                   count++;
  296.                   *wfdp |= mask;
  297. +                 case 0:
  298. +                 wfd &= ~mask;
  299. +                 }
  300.               }
  301.           }
  302.           mask = mask << 1L;
  303.       }
  304.   
  305.       if (count == 0) {
  306. !     /* OK, now let's set a timeout, but only the first time we get here */
  307.   
  308. !         if (!t && timeout) {
  309.               t = addtimeout((long)timeout, unselectme);
  310.           }
  311.   
  312.           sr = spl7();
  313. ***************
  314. *** 1037,1044 ****
  315.       /* curproc->wait_cond changes when data arrives or the timeout happens */
  316.           while (curproc->wait_cond == (long)wakeselect) {
  317.               TRACE(("sleeping in Fselect"));
  318. !             sleep(SELECT_Q, (long)wakeselect);
  319.           }
  320.           spl(sr);
  321.   
  322.       /* we can cancel the time out now (if it hasn't already happened) */
  323. --- 1060,1076 ----
  324.       /* curproc->wait_cond changes when data arrives or the timeout happens */
  325.           while (curproc->wait_cond == (long)wakeselect) {
  326.               TRACE(("sleeping in Fselect"));
  327. !             if (rfd || wfd) {
  328. !                 sleep(SELECT_Q, (long)&select_coll);
  329. !             } else {
  330. !                 sleep(SELECT_Q, (long)wakeselect);
  331. !             }
  332.           }
  333. +         if (curproc->wait_cond == (long)&select_coll) {
  334. +             curproc->wait_cond = (long)wakeselect;
  335. +             spl(sr);
  336. +             goto retry_after_collision;
  337. +         }
  338.           spl(sr);
  339.   
  340.       /* we can cancel the time out now (if it hasn't already happened) */
  341. ***************
  342. *** 1047,1053 ****
  343.       /* OK, let's see what data arrived (if any) */
  344.           mask = 1L;
  345.           for (i = 0; i < MAX_OPEN; i++) {
  346. !             if (rfd & mask) {
  347.                   f = p->handle[i];
  348.                   if (f) {
  349.                       bytes = 1L;
  350. --- 1079,1085 ----
  351.       /* OK, let's see what data arrived (if any) */
  352.           mask = 1L;
  353.           for (i = 0; i < MAX_OPEN; i++) {
  354. !             if (orfd & mask) {
  355.                   f = p->handle[i];
  356.                   if (f) {
  357.                       bytes = 1L;
  358. ***************
  359. *** 1058,1064 ****
  360.                       }
  361.                   }
  362.               }
  363. !             if (wfd & mask) {
  364.                   f = p->handle[i];
  365.                   if (f) {
  366.                       bytes = 1L;
  367. --- 1090,1096 ----
  368.                       }
  369.                   }
  370.               }
  371. !             if (owfd & mask) {
  372.                   f = p->handle[i];
  373.                   if (f) {
  374.                       bytes = 1L;
  375. ***************
  376. *** 1071,1089 ****
  377.               }
  378.               mask = mask << 1L;
  379.           }
  380. !     }
  381.   
  382.       /* at this point, we either have data or a time out */
  383.       /* cancel all the selects */
  384.       mask = 1L;
  385.   
  386.       for (i = 0; i < MAX_OPEN; i++) {
  387. !         if (rfd & mask) {
  388.               f = p->handle[i];
  389.               if (f)
  390.                   (*f->dev->unselect)(f, (long)p, O_RDONLY);
  391.           }
  392. !         if (wfd & mask) {
  393.               f = p->handle[i];
  394.               if (f)
  395.                   (*f->dev->unselect)(f, (long)p, O_WRONLY);
  396. --- 1103,1127 ----
  397.               }
  398.               mask = mask << 1L;
  399.           }
  400. !     } else if (t) {
  401.   
  402. +     /* in case data arrived after a collsion, there
  403. +      * could be a timeout pending even if count > 0
  404. +      */
  405. +         canceltimeout(t);
  406. +     }
  407. +     
  408.       /* at this point, we either have data or a time out */
  409.       /* cancel all the selects */
  410.       mask = 1L;
  411.   
  412.       for (i = 0; i < MAX_OPEN; i++) {
  413. !         if (orfd & mask) {
  414.               f = p->handle[i];
  415.               if (f)
  416.                   (*f->dev->unselect)(f, (long)p, O_RDONLY);
  417.           }
  418. !         if (owfd & mask) {
  419.               f = p->handle[i];
  420.               if (f)
  421.                   (*f->dev->unselect)(f, (long)p, O_WRONLY);
  422. ***************
  423. *** 1091,1096 ****
  424. --- 1129,1138 ----
  425.           mask = mask << 1L;
  426.       }
  427.   
  428. +     /* wake other processes which got a collision */
  429. +     if (orfd || owfd)
  430. +         wake(SELECT_Q, (long)&select_coll);
  431. + 
  432.       TRACE(("Fselect: returning %d", count));
  433.       return count;
  434.   }
  435. *** pipefs.c.orig    Mon Sep 13 21:42:50 1993
  436. --- pipefs.c    Mon Sep 13 21:44:34 1993
  437. ***************
  438. *** 1010,1018 ****
  439.               return 1;
  440.           }
  441.   
  442. ! /* BUG: multiple selects fail, only the first one works */
  443. !         if (!p->rsel)
  444. !             p->rsel = proc;
  445.           return 0;
  446.       } else if (mode == O_WRONLY) {
  447.           p = (f->flags & O_HEAD) ? this->inp : this->outp;
  448. --- 1010,1018 ----
  449.               return 1;
  450.           }
  451.   
  452. !         if (p->rsel)
  453. !             return 2; /* collision */
  454. !         p->rsel = proc;
  455.           return 0;
  456.       } else if (mode == O_WRONLY) {
  457.           p = (f->flags & O_HEAD) ? this->inp : this->outp;
  458. ***************
  459. *** 1024,1031 ****
  460.           if (j >= PIPESIZ) j = 0;
  461.           if (j != p->head || p->readers <= 0)
  462.               return 1;    /* data may be written */
  463. !         if (!p->wsel)
  464. !             p->wsel = proc;
  465.           return 0;
  466.       }
  467.       return 0;
  468. --- 1024,1032 ----
  469.           if (j >= PIPESIZ) j = 0;
  470.           if (j != p->head || p->readers <= 0)
  471.               return 1;    /* data may be written */
  472. !         if (p->wsel)
  473. !             return 2; /* collsion */
  474. !         p->wsel = proc;
  475.           return 0;
  476.       }
  477.       return 0;
  478. *** proc.c.orig    Mon Sep 13 21:22:00 1993
  479. --- proc.c    Mon Sep 13 21:23:40 1993
  480. ***************
  481. *** 608,616 ****
  482.   {
  483.       PROC *p = (PROC *)param;
  484.       short s;
  485. ! 
  486.       s = spl7();    /* block interrupts */
  487. !     if(p->wait_cond == (long)wakeselect) {
  488.           p->wait_cond = 0;
  489.       }
  490.       if (p->wait_q == SELECT_Q) {
  491. --- 608,618 ----
  492.   {
  493.       PROC *p = (PROC *)param;
  494.       short s;
  495. !     extern short select_coll; /* in dosfile.c */
  496. !     
  497.       s = spl7();    /* block interrupts */
  498. !     if(p->wait_cond == (long)wakeselect ||
  499. !        p->wait_cond == (long)&select_coll) {
  500.           p->wait_cond = 0;
  501.       }
  502.       if (p->wait_q == SELECT_Q) {
  503. *** signal.c.orig    Fri Sep 17 15:32:58 1993
  504. --- signal.c    Fri Sep 17 15:54:14 1993
  505. ***************
  506. *** 56,62 ****
  507.       int sig;
  508.   {
  509.       ulong sigm;
  510. ! 
  511.   /* if process is ignoring this signal, do nothing
  512.    * also: signal 0 is SIGNULL, and should never be delivered through
  513.    * the normal channels (indeed, it's filtered out in dossig.c,
  514. --- 56,64 ----
  515.       int sig;
  516.   {
  517.       ulong sigm;
  518. !     short sr;
  519. !     extern short select_coll; /* in dosfile.c */
  520. !     
  521.   /* if process is ignoring this signal, do nothing
  522.    * also: signal 0 is SIGNULL, and should never be delivered through
  523.    * the normal channels (indeed, it's filtered out in dossig.c,
  524. ***************
  525. *** 83,93 ****
  526.       if ( (p->sigmask & sigm) != 0 )
  527.           return;
  528.   
  529.   /* otherwise, make sure the process is awake */
  530.       if (p->wait_q && p->wait_q != READY_Q) {
  531. !         short sr = spl7();
  532. !         if (p->wait_q == SELECT_Q)
  533. !             p->wait_cond = 0;
  534.           rm_q(p->wait_q, p);
  535.           add_q(READY_Q, p);
  536.           spl(sr);
  537. --- 85,104 ----
  538.       if ( (p->sigmask & sigm) != 0 )
  539.           return;
  540.   
  541. + /* Notify p, if p is selecting. After a wake(SELECT_Q, (long)&select_coll)
  542. +  * p might be on READY_Q with p->wait_cond == &select_coll. Posting p a
  543. +  * signal then requires clearing p->wait_cond even if p is not on SELECT_Q.
  544. +  */
  545. +     sr = spl7();
  546. +     if (p->wait_cond == (long)wakeselect ||
  547. +         p->wait_cond == (long)&select_coll) {
  548. +         p->wait_cond = 0;
  549. +     }
  550. +     spl(sr);
  551. +     
  552.   /* otherwise, make sure the process is awake */
  553.       if (p->wait_q && p->wait_q != READY_Q) {
  554. !         sr = spl7();
  555.           rm_q(p->wait_q, p);
  556.           add_q(READY_Q, p);
  557.           spl(sr);
  558.  
  559.